package algorithm_demo.demo_advanced;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

/**
 * 单调栈实现（无重复数+有重复数）
 *
 * 单调递增栈： 从栈顶往栈底看，是单调递增的关系（含相等）
 * 单调递减栈： 从栈顶往栈底看，是单调递减的关系（含相等）
 *
 * 从一个数组中，获取出每个元素左边离它最近的元素和右边离它最近的元素，如果没有用-1表示（数组内元素不重复）
 * 从一个数组中，获取出每个元素左边离它最近的元素和右边离它最近的元素，如果没有用-1表示（数组内元素可重复）
 * @author Api
 * @date 2023/3/25 22:59
 */
public class Code03_MonotonousStack {
    /*不重复的数组*/
    /*从一个数组中，获取出每个元素左边离它最近的元素和右边离它最近的元素，如果没有用-1表示（数组内元素不重复）*/
    public static int[][] getNearLessNoRepeat(int[] arr){
        int[][] res = new int[arr.length][2];
        //只存位置
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < arr.length; i++){
            while(!stack.isEmpty() && arr[stack.peek()] > arr[i]){
                int j = stack.pop();
                int leftLessIndex = stack.isEmpty()? -1:stack.peek();
                res[j][0] = leftLessIndex;
                res[j][1] = i;
            }
            stack.push(i);
        }
        while(!stack.isEmpty()){
            int j = stack.pop();
            int leftLessIndex = stack.isEmpty()?-1:stack.peek();
            res[j][0] = leftLessIndex;
            res[j][1] = -1;
        }
        return res;
    }
    /*从一个数组中，获取出每个元素左边离它最近的元素和右边离它最近的元素，如果没有用-1表示（数组内元素可重复）*/
    /*时间复杂度：O(N)*/
    public static int[][] getNearLess(int[] arr){
        int[][] res = new int[arr.length][2];
        //List<Integer> ->放的是位置，同样值的东西，位置压在一起
        Stack<List<Integer>> stack = new Stack<List<Integer>>();
        for(int i = 0;i<arr.length;i++){//i->arr[i]进栈
            //底 -> 顶，小 -> 大
            while(!stack.isEmpty() && arr[stack.peek().get(0)]> arr[i]){
                List<Integer> popIs = stack.pop();
                //取位于下面位置的列表中，最晚加入的那个
                int leftLessIndex = stack.isEmpty()? -1:stack.peek().get(stack.peek().size()-1);
                for(Integer popi:popIs){
                    res[popi][0] = leftLessIndex;
                    res[popi][1] = i;
                }
            }
            //相等的，比你小的
            if (!stack.isEmpty() && arr[stack.peek().get(0)] == arr[i]){
                stack.peek().add(i);
            }else{
                List<Integer> list = new ArrayList<>();
                list.add(i);
                stack.push(list);
            }
        }
        while(!stack.isEmpty()){
            List<Integer> popIs = stack.pop();
            //取位于下面的位置的列表中，最晚加入的那个
            int leftLessIndex = stack.isEmpty()?-1:stack.peek().get(stack.peek().size()-1);
            for(Integer popi:popIs){
                res[popi][0] = leftLessIndex;
                res[popi][1] = -1;
            }
        }
        return res;
    }
}
